(post
 :title "(display \"Hello, World!\")"
 :date (make-date* 2016 04 12 16 00)
 :tags '("hello")
 :slug "hello-world"

 (p [Hello everyone!
     Time to test the sanity of this system, yeah?])

 (p [So, this is the soft launch of the 8sync website.
     There's not ,(em [too much]) to see quite yet.
     I need to make a proper release, etc.])

 (p [But maybe you're wondering what this crazy 8sync thing is?
     Well, as the name implies, it's an asynchronous event loop
     (hence the pun, 8-synchronous... the logo has an infinity symbol...) for
     ,(anchor [GNU Guile] "http://www.gnu.org/software/guile/").
     If you're familiar with
     ,(anchor [Node.js] "https://nodejs.org/en/")
     for Javascript or
     ,(anchor [asyncio] "https://docs.python.org/3/library/asyncio.html")
     for Python, you might know a bit about what I mean by
     "asynchronous event loop".
     So, why bring another event loop into the world?])

 (p [Well, as things tend to go, I initially wrote 8sync largely for
     myself.
     I've spent enough time in other asynchronous systems to know that
     I'm just not very happy working in them.
     I knew I wanted a system with the following properties:])

 (ul
  (li (p [Absolutely no "callback hell".
          Asynchronous code is as easy to read as synchronous code.])
      (p [Most event loops end up with you chaining different event
          commands together manually and what in a synchronous program
          might be a strightforward piece of code gets very confusingly
          threaded across many pieces of code.
          I was inspired by asyncio's coroutine support, but hoped that I
          could achieve even better.
          asyncio requires that you very carefully "line up" coroutines
          so that they fit together.
          8sync avoids this by making use of
          ,(anchor [delimited continuations]
                   "https://www.gnu.org/software/guile/manual/html_node/Prompts.html")
          under the hood.
          However, most users will never have to learn how delimited
          continuations work, 8sync provides the (8sync) special form.
          Yay, abstractions!]))

  (li (p [Live hackable.
          I wanted a system that I could modify and play with while the
          system is running.
          No need to restart.
          I want my editor, my code, and my REPL all interconnected.
          So, 8sync has nice integration with
          ,(anchor [Geiser] "http://geiser.nongnu.org/") and
          ,(anchor [Emacs] "http://www.gnu.org/software/emacs/").
          (It's a bit dated, but I still find David Thompson's video of
            ,(anchor [live hacking in Sly]
                     "https://dthompson.us/functional-reactive-programming-in-scheme-with-guile-2d.html")
            to be a massive inspiration).]))

  (li (p [Ideally, in some kind of lisp.
          Well, I like lisps, but in a certain sense, this is
          ,(em [because]) of the above goals.
          Lisps tend to be well suited for "REPL driven development"
          and forging the syntax necessary to make solving problems
          easier.
          And I was spending a lot of time in Guile, so of course
          having something in Guile would be nice.])))

 (p [I had the good fortune at the FSF 30th anniversary party to sit
     down with Guile hackers David Thompson and Mark Weaver, and we
     ,(anchor [had a nice brainstorm about what a good asynchronous
               event loop in Guile might look like]
              "https://lists.gnu.org/archive/html/guile-devel/2015-10/msg00015.html").
     At the time I still assumed I would convince someone else to do
     the work, but then I started coding a mockup, and oh hey!
     The mockup started to turn into something pretty nice.
     And so, 8sync was born.])

 (p [So anyway, it's still early days for 8sync.
     Today is the launch of the 8sync site.
     Horray!
     (Happily, this site is built with David Thompson's
       ,(anchor [Haunt] "https://haunt.dthompson.us/"),
       which is a real delight to use!)
     And, as you can see, we're a GNU project, which is pretty cool.
     Hopefully sometime in the next few days, an official 8sync
     release will come out... 0.1!
     After that, I might end up doing more integration with some of
     the port refactoring work Andy Wingo is doing in Guile.
     At the very least, 8sync has demonstrated some good ideas,
     but there are some goofy things to clean up too
     (why are we using select instead of poll/epoll?).])
 
 (p [Lots to do!
     And so, hello world, it's nice to meet you.
     See you again soon!]))
